proxy/process.go (2)

314-337: TTL unload loop has two issues: potential leak and premature exit; also zero-time triggers immediate unload

• time.Tick leaks (SA1015). Use time.NewTicker.
• The loop returns if state != Ready; since the goroutine starts before Ready, it can exit before TTL ever runs.
• lastRequestHandled starts at zero; time.Since(zero) is large, so it may unload immediately on first tick if no requests have completed.

Fix by initializing lastRequestHandled when enabling TTL, waiting until Ready, and using a ticker.

As per coding guidelines (staticcheck)

-        go func() {
-            maxDuration := time.Duration(p.config.UnloadAfter) * time.Second
-
-            for range time.Tick(time.Second) {
-                if p.CurrentState() != StateReady {
-                    return
-                }
-
-                // skip the TTL check if there are inflight requests
-                if p.inFlightRequestsCount.Load() != 0 {
-                    continue
-                }
-
-                if time.Since(p.getLastRequestHandled()) > maxDuration {
-                    p.proxyLogger.Infof("<%s> Unloading model, TTL of %ds reached", p.ID, p.config.UnloadAfter)
-                    p.Stop()
-                    return
-                }
-            }
-        }()
+        // Initialize to now so we don't unload immediately before first request completes.
+        p.setLastRequestHandled(time.Now())
+        go func() {
+            maxDuration := time.Duration(p.config.UnloadAfter) * time.Second
+            ticker := time.NewTicker(time.Second)
+            defer ticker.Stop()
+            for range ticker.C {
+                st := p.CurrentState()
+                // Exit when process stops/shuts down; otherwise wait until Ready
+                if st == StateStopped || st == StateShutdown {
+                    return
+                }
+                if st != StateReady {
+                    continue
+                }
+                // Skip while requests are in-flight
+                if p.inFlightRequestsCount.Load() != 0 {
+                    continue
+                }
+                if !p.getLastRequestHandled().IsZero() && time.Since(p.getLastRequestHandled()) > maxDuration {
+                    p.proxyLogger.Infof("<%s> Unloading model, TTL of %ds reached", p.ID, p.config.UnloadAfter)
+                    p.Stop()
+                    return
+                }
+            }
+        }()

---

347-357: Stop() waits before transitioning to Stopping → can hang under load

Stop() waits for in-flight requests while state remains Ready, allowing new requests to arrive and preventing the WaitGroup from draining. Transition to Stopping first to reject new requests, then wait and stop.

 func (p *Process) Stop() {
-    if !isValidTransition(p.CurrentState(), StateStopping) {
-        return
-    }
-
-    // wait for any inflight requests before proceeding
-    p.proxyLogger.Debugf("<%s> Stop(): Waiting for inflight requests to complete", p.ID)
-    p.inFlightRequests.Wait()
-    p.StopImmediately()
+    // Transition first to reject new requests, then wait and stop.
+    if curState, err := p.swapState(StateReady, StateStopping); err != nil {
+        p.proxyLogger.Infof("<%s> Stop(): Ready -> Stopping failed: %v (current: %v)", p.ID, err, curState)
+        return
+    }
+    p.proxyLogger.Debugf("<%s> Stop(): Waiting for inflight requests to complete", p.ID)
+    p.inFlightRequests.Wait()
+    p.stopCommand()
 }